/*
 * Agence.cpp
 *
 *  Created on: 23 mars 2012
 *      Author: root
 */

#include "Agence.h"
#include "Parking.h"
#include<fstream>
#include<string>
#include<iostream>

using namespace std;
//les constructeurs:

Agence::Agence()
{
	ClientFileName="txt/Fichier_Client.txt";
	VehiculeFileName="txt/Fichier_Vehicule.txt";
	RendreVehiculeFileName="txt/Fichier_Rendre_Vehicule.txt";
	ReserverVehiculeFileName="txt/Fichier_Reserver_Vehicule.txt";
	AgenceFileName="txt/Agence_Fichier.txt";
	ParkingFileName="txt/Parking_Fichier.txt";
	FileNameTemp="txt/temp.txt";
	Vehicule_utilitaireFileName="txt/Vehicule_Utilitaire.txt";
	Vehicule_touristiqueFileName="txt/Vehicule_touristique.txt";

}

Agence::Agence(string NomAgence, long NumAgence, string AdresseAgence, long Tel, string NomAgent, long IdentifiantAgent,string Login,string Password)
{
	this->NumAgence=NumAgence;
	this->Tel=Tel;
	this->IdentifiantAgent=IdentifiantAgent;
	this->NomAgence=NomAgence;
	this->AdresseAgence=AdresseAgence;
	this->NomAgent=NomAgent;
	this->Login=Login;
	this->Password=Password;
	this->ClientFileName="txt/Fichier_Client.txt";
	this->VehiculeFileName="txt/Fichier_Vehicule.txt";
	this->RendreVehiculeFileName="txt/Fichier_Rendre_Vehicule.txt";
	this->ReserverVehiculeFileName="txt/Fichier_Reserver_Vehicule.txt";
	this->AgenceFileName="txt/Agence_Fichier.txt";
	this->ParkingFileName="txt/Parking_Fichier.txt";
	this->FileNameTemp="txt/temp.txt";
	this->Vehicule_utilitaireFileName="txt/Vehicule_Utilitaire.txt";
	this->Vehicule_touristiqueFileName="txt/Vehicule_touristique.txt";
}

Agence::~Agence() {}

//les getteurs et les setteurs:

long Agence::getNumAgence()const
{
	return this->NumAgence;
}

void Agence::setNumAgence(long NumAgence)
{
	this->NumAgence=NumAgence;
}

long Agence::getTel()const
{
	return this->Tel;
}

void Agence::setTel(long Tel)
{
	this->Tel=Tel;
}

long Agence::getIdentifiantAgent()const
{
	return this->IdentifiantAgent;
}

void Agence::setIdentifiantAgent(long IdentifiantAgent)
{
	this->IdentifiantAgent=IdentifiantAgent;
}
string Agence::getNomAgence()const
{
	return this->NomAgence;
}

void Agence::setNomAgence(string NomAgence)
{
	this->NomAgence=NomAgence;
}

string Agence::getNomAgent()const
{
	return this->NomAgent;
}

void Agence::setNomAgent(string NomAgent)
{
	this->NomAgent=NomAgent;
}

string Agence::getAdresseAgence()const
{
	return this->AdresseAgence;
}
void Agence::setAdresseAgence(string AdresseAgence)
{
	this->AdresseAgence=AdresseAgence;
}

string Agence::getLogin()const
{
	return this->Login;
}
void Agence::setLogin(string Login)
{
	this->Login=Login;
}

string Agence::getPassword()const
{
	return this ->Password;
}
void Agence::setPassword(string)
{
	this->Password=Password;
}

// LES CLIENTS

int Agence::IdentifierAgent(string Login, string Password)
{
	ifstream myfile;
	Agence A;
	myfile.open (AgenceFileName.c_str());
	if(!myfile.is_open())
	{	cout<<"Impossible d'ouvrir le fichier : Fichier_Agence  "<<endl;
	}
	else
	{long k=0;
	int kk;
	int bb;
		while(!myfile.eof())
		{	myfile>>A;
			if(A.getNumAgence()!=k)
			{	kk = A.getLogin().compare(Login);
		 		bb = A.getPassword().compare(Password);	
				if((A.getLogin().compare(Login)==0)&&(A.getPassword().compare(Password)==0))
				{	return 0;
				}
			}
			k=getNumAgence();
		}
		myfile.close();
	}
	return 1;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool Agence::VerifierClient(long Cin)
{
ifstream myfile;
Client C;

myfile.open(ClientFileName.c_str());

if(!myfile.is_open())
{	cout<<"impossible d'ouvrir le Fichier : Fichier_Client "<<endl;
	return false;}
while(!myfile.eof())
{	myfile>>C;
	if(C.getCIN()==Cin)
	{	myfile.close();					
		return false;}
}
myfile.close();
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

bool Agence::AjouterClient(const Client& C)
{
ofstream myfile;
myfile.open (ClientFileName.c_str(),ios::app);
	
if(!myfile.is_open())
{
	cout<<"Impossible d'ouvrir le fichier : Fichier_Client  "<<endl;
	return false;
}
else
{	myfile<<C<<endl;						
	myfile.close();}
	return true;
}

////////////////////////////////////////////////////////Parking plus////////////////////////////////////////////////////////////////////////////////
bool Agence::EntrerVehiculePlus(long NumParking)
{
ifstream myfile4;
ofstream myfile_temp;
Parking P;

myfile4.open(ParkingFileName.c_str());
myfile_temp.open(FileNameTemp.c_str(),ios::app);
if((!myfile4.is_open())&&(!myfile_temp.is_open()))
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Parking ou Fichier temp  "<<endl;
	return false;}
else
{int k=0;
	while(!myfile4.eof())
	{	myfile4>>P;
		if(k!=P.getNumParking())
		{
			if((P.getNumParking()==NumParking)&&(P.getCapaciteParking()>P.getNombreDePlaceOccupe()))
			{	int X=P.getNombreDePlaceOccupe()+1;
				P.setNombreDePlaceOccupe(X);
				myfile_temp<<P<<endl;}
			else
			{	myfile_temp<<P<<endl;
			}
			k=P.getNumParking();
		}
		else
		{
		}
	}
myfile4.close();
myfile_temp.close();
	remove(ParkingFileName.c_str());
	rename(FileNameTemp.c_str(),ParkingFileName.c_str());
}
return true;
}
/////////////////////////////////////////////////////////Rendre Vehicule////////////////////////////////////////////////////////////////////////////

bool Agence::RendreVehicul(const RendreVehicule& RV)
{
ofstream myfile2;	
myfile2.open(RendreVehiculeFileName.c_str(),ios::app);

if(!myfile2.is_open())
{	cout<<"impossible d'ouvrir le Fichier : Fichier_Rendre_Vehicule "<<endl;
	return false;}
else
{	myfile2<<RV<<endl;	
	myfile2.close();
}
return true;
}
//////////////////////////////////////////////////////////////TESTER ETAT DISPO/////////////////////////////////////////////////////////////////////

bool Agence:: TesterEtatDispoVehi(string NumMatricule)
{
ifstream myfile3;
Vehicule V;
myfile3.open(VehiculeFileName.c_str());
if(!myfile3.is_open())
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Vehicule ou Fichier temp  "<<endl;
	return false;}
else
{	while(!myfile3.eof())
	{	myfile3>>V;
		if(V.getNumMatricule().compare(NumMatricule)==0)
		{	if(V.getEtatDeDisponibilite()==false)
			{return false;
			}
		}
		myfile3>>V;
	}
}
return true;}

/////////////////////////////////////////////////changer etat dispo/////////////////////////////////////////////////////////////////////////////////
bool Agence::ChangeEtatDispoVehiRendu(string NumMatricule,long NumParking)	
{
ifstream myfile3;
ofstream myfile_temp;
Vehicule V;	
myfile3.open(VehiculeFileName.c_str());
myfile_temp.open(FileNameTemp.c_str(), ios::app);
		
if((!myfile3.is_open())&&(!myfile_temp.is_open()))
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Vehicule ou Fichier temp  "<<endl;
	return false;}
else
{string k="0";
	while(!myfile3.eof())
	{	myfile3>>V;
		if(k.compare(V.getNumMatricule())!=0)
		{	if(V.getNumMatricule().compare(NumMatricule)==0)
			{	V.setEtatDeDisponibilite(0);
				V.setNumParking(NumParking);
				myfile_temp<<V<<endl;}
			else
			{	myfile_temp<<V<<endl;
			}
			k=V.getNumMatricule();
		}
		else
		{
		}
	}
myfile3.close();
myfile_temp.close();
		remove(VehiculeFileName.c_str());
		rename(FileNameTemp.c_str(),VehiculeFileName.c_str());
}					
	return true;
}

///////////////////////////////////////////////////Rendre Vehicule Utilitaire////////////////////////////////////////////////////////////////////////

bool Agence::RendreVehiculUtilitaire(const RendreVehicule& RV)
{
ofstream myfile2;
myfile2.open(RendreVehiculeFileName.c_str(),ios::app);

if(!myfile2.is_open())
{	cout<<"impossible d'ouvrir le Fichier : Fichier_Rendre_Vehicule "<<endl;
	return false;}
else
{	myfile2<<RV<<endl;
	myfile2.close();}
return true;
}
///////////////////////////////////////////////////tester etat dispo///////////////////////////////////////////////////////////////////////////////

bool Agence:: TesterEtatDispoVehiUtili(string NumMatricule)
{
ifstream myfile3;
VehiculeUtilitaire V;
myfile3.open(Vehicule_utilitaireFileName.c_str());
if(!myfile3.is_open())
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Vehicule ou Fichier temp  "<<endl;
	return false;}
else
{	while(!myfile3.eof())
	{	myfile3>>V;
		if(V.getNumMatricule().compare(NumMatricule)==0)
		{	if(V.getEtatDeDisponibilite()==false)
			{	return false;
			}
		}
	}
}
return true;}

////////////////////////////////////////////////etat dispo veh rendu///////////////////////////////////////////////////////////////////////////////

bool Agence::ChangerEtatDispoVehiUtiliRendu(string NumMatricule, long NumParking)
{
ifstream myfile3;
ofstream myfile_temp;
VehiculeUtilitaire V;

myfile3.open(Vehicule_utilitaireFileName.c_str());
myfile_temp.open(FileNameTemp.c_str(),ios::app);
if((!myfile3.is_open())&&(!myfile_temp.is_open()))
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Vehicule ou Fichier temp  "<<endl;
	return false;}
else
{string k="0";
	while(!myfile3.eof())
	{	myfile3>>V;
		if(k.compare(V.getNumMatricule())!=0)
		{	if(V.getNumMatricule().compare(NumMatricule)==0)
			{	V.setEtatDeDisponibilite(0);
				V.setNumParking(NumParking);
				myfile_temp<<V<<endl;}
			else
			{	myfile_temp<<V<<endl;
			}
			k=V.getNumMatricule();
		}
		else
		{
		}
	}
myfile3.close();
myfile_temp.close();
	remove(Vehicule_utilitaireFileName.c_str());
	rename(FileNameTemp.c_str(),Vehicule_utilitaireFileName.c_str());
}	
	return true;
}

//////////////////////////////////////////////////////Rendre Vehicule Touristique///////////////////////////////////////////////////////////////////////////////////

bool Agence::RendreVehiculTouristique(const RendreVehicule& RV)
{
ofstream myfile2;
myfile2.open(RendreVehiculeFileName.c_str(),ios::app);

if(!myfile2.is_open())
{	cout<<"impossible d'ouvrir le Fichier : Fichier_Rendre_Vehicule "<<endl;
	return false;}
else
{	myfile2<<RV<<endl;;
	myfile2.close();}
return true;
}	
/////////////////////////////////////////////////////tester etat dispo vehi touristique////////////////////////////////////////////////////////////
bool Agence:: TesterEtatDispoVehiTouristique(string NumMatricule)
{
ifstream myfile3;
VehiculeTouristique V;
myfile3.open(Vehicule_touristiqueFileName.c_str());
if(!myfile3.is_open())
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Vehicule ou Fichier temp  "<<endl;
	return false;}
else
{	while(!myfile3.eof())
	{	myfile3>>V;
		if(V.getNumMatricule().compare(NumMatricule)==0)
		{	if(V.getEtatDeDisponibilite()==false)
			{	return false;
			}
		}
	}
}
return true;}
///////////////////////////////////////////////////////changr etat dispo vehi rendu////////////////////////////////////////////////////////////////
bool Agence::ChangerEtatDispoVehiTouriRendu(string NumMatricule, long NumParking)
{
ifstream myfile3;
ofstream myfile_temp;
VehiculeTouristique V;

myfile3.open(Vehicule_touristiqueFileName.c_str());
myfile_temp.open(FileNameTemp.c_str(),ios::app);
if((!myfile3.is_open())&&(!myfile_temp.is_open()))
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Vehicule ou Fichier temp  "<<endl;
	return false;
}
else
{string k="0";
	while(!myfile3.eof())
	{	myfile3>>V;
		if(k.compare(V.getNumMatricule())!=0)
		{	if(V.getNumMatricule().compare(NumMatricule)==0)
			{	V.setEtatDeDisponibilite(0);
				V.setNumParking(NumParking);
				myfile_temp<<V<<endl;}
			else
			{	myfile_temp<<V<<endl;
			}
			k=V.getNumMatricule();
		}
		else
		{
		}
	}
myfile3.close();
myfile_temp.close();
	remove(Vehicule_touristiqueFileName.c_str());
	rename(FileNameTemp.c_str(),Vehicule_touristiqueFileName.c_str());
}
	return true;
}

////////////////////////////////////////////////////////////////reserver vehicule ////////////////////////////////////////////////////////////////

bool Agence::ReserverVehicule(const Reservation& RE)
{	
ofstream myfile2;
myfile2.open(ReserverVehiculeFileName.c_str(),ios::app);

if(!myfile2.is_open())
{	cout<<"impossible d'ouvrir le Fichier : Fichier_Client ou le Ficher_Reservation "<<endl;
	return false;
}
else
{	myfile2<<RE<<endl;
	myfile2.close();
}
return true;
}

//////////////////////////////////////////////////////////////test etat dispo//////////////////////////////////////////////////////////////////////
bool Agence::TesterEtatDeDisponibiliteReserver(string NumMatricule)
{
ifstream myfile3;
Vehicule V;

myfile3.open(VehiculeFileName.c_str());
if(!myfile3.is_open())
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Vehicule ou Fichier temp  "<<endl;
	return false;
}
else
{	while(!myfile3.eof())
	{	myfile3>>V;
		if(V.getNumMatricule().compare(NumMatricule)==0)
		{	if(V.getEtatDeDisponibilite()==1)
			{	return false;
			}
		}
		myfile3>>V;
	}
myfile3.close();
}
return true;
}
		
///////////////////////////////////////////////////////////////////changer etat dispo vehi////////////////////////////////////////////////////////////////////////
bool Agence::ChangerEtatDeDisponibiliteReserver(string NumMatricule)
{
ifstream myfile3;
ofstream myfiletemp;

Vehicule V;
myfile3.open(VehiculeFileName.c_str());
myfiletemp.open(FileNameTemp.c_str(), ios::app);
if((!myfile3.is_open())&&(!myfiletemp.is_open()))
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Vehicule ou Fichier temp  "<<endl;
	return false;
}
else
{string k="0";
	while(!myfile3.eof())
	{	myfile3>>V;
		if(k.compare(V.getNumMatricule())!=0)
		{	if(V.getNumMatricule().compare(NumMatricule)==0)
			{	V.setEtatDeDisponibilite(1);
				V.setNumParking(0);
				myfiletemp<<V<<endl;}
			else
			{	myfiletemp<<V<<endl;
			}
			k=V.getNumMatricule();
		}
		else
		{
		}
	}
myfile3.close();
myfiletemp.close();
	remove(VehiculeFileName.c_str());
	rename(FileNameTemp.c_str(),VehiculeFileName.c_str());
}
return true;
}		
///////////////////////////////////////////////////////////////////sortie vehicule//////////////////////////////////////////////////////////////////
bool Agence::SortieVehiculeMoin(string NumMatricule)
{	
ifstream myfile4;
ofstream myfile_temp;
ifstream myfile3;

Parking P;
Vehicule V;
long N;
myfile3.open(VehiculeFileName.c_str());

if(!myfile3.is_open())
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Vehicule  "<<endl;
	return false;
}
else
{string k="0";
	while(!myfile3.eof())
	{	myfile3>>V;
		if(k.compare(V.getNumMatricule())!=0)
		{	if(V.getNumMatricule().compare(NumMatricule)==0)
			{	
				N = V.getNumParking();
			}
			k=V.getNumMatricule();
		}
	}
}
myfile3.close();

myfile4.open(ParkingFileName.c_str());
myfile_temp.open(FileNameTemp.c_str(),ios::app);

if((!myfile4.is_open())&&(!myfile_temp.is_open()))
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Parking ou Fichier temp  "<<endl;
	return false;
}

else
{int k=0;
	while(!myfile4.eof())
	{	myfile4>>P;
		if(k!=P.getNumParking())
		{
			if((P.getNumParking()==N)&&(P.getNombreDePlaceOccupe()>0))
			{	int X=P.getNombreDePlaceOccupe()-1;
				P.setNombreDePlaceOccupe(X);
				myfile_temp<<P<<endl;}
			else
			{	myfile_temp<<P<<endl;
			}
			k=P.getNumParking();
		}
		else
		{
		}
	}
myfile4.close();
myfile_temp.close();
		remove(ParkingFileName.c_str());
		rename(FileNameTemp.c_str(),ParkingFileName.c_str());
}
return true;
}

///////////////////////////////////////////////////////////////////sortie vehicule Utilitaire//////////////////////////////////////////////////////////////////
bool Agence::SortieVehiculeUtilitaireMoin(string NumMatricule)
{	
ifstream myfile4;
ofstream myfile_temp;
ifstream myfile3;

Parking P;
Vehicule V;
long N; 
myfile3.open(Vehicule_utilitaireFileName.c_str());

if(!myfile3.is_open())
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Vehicule utilitaire  "<<endl;
	return false;
}
else
{string k="0";
	while(!myfile3.eof())
	{	myfile3>>V;
		if(k.compare(V.getNumMatricule())!=0)
		{	if(V.getNumMatricule().compare(NumMatricule)==0)
			{	
				N = V.getNumParking();
			}
			k=V.getNumMatricule();
		}
	}
}
myfile3.close();

myfile4.open(ParkingFileName.c_str());
myfile_temp.open(FileNameTemp.c_str(),ios::app);

if((!myfile4.is_open())&&(!myfile_temp.is_open()))
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Parking ou Fichier temp  "<<endl;
	return false;
}

else
{int k=0;
	while(!myfile4.eof())
	{	myfile4>>P;
		if(k!=P.getNumParking())
		{
			if((P.getNumParking()==N)&&(P.getNombreDePlaceOccupe()>0))
			{	int X=P.getNombreDePlaceOccupe()-1;
				P.setNombreDePlaceOccupe(X);
				myfile_temp<<P<<endl;}
			else
			{	myfile_temp<<P<<endl;
			}
			k=P.getNumParking();
		}
		else
		{
		}
	}
myfile4.close();
myfile_temp.close();
		remove(ParkingFileName.c_str());
		rename(FileNameTemp.c_str(),ParkingFileName.c_str());
}
return true;
}


///////////////////////////////////////////////////////////////////sortie vehicule touristique//////////////////////////////////////////////////////////////////
bool Agence::SortieVehiculeTouristiqueMoin(string NumMatricule)
{	
ifstream myfile4;
ofstream myfile_temp;
ifstream myfile3;

Parking P;
Vehicule V;
long N ;

myfile3.open(Vehicule_touristiqueFileName.c_str());

if(!myfile3.is_open())
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Vehicule touristique  "<<endl;
	return false;
}
else
{string k="0";
	while(!myfile3.eof())
	{	myfile3>>V;
		if(k.compare(V.getNumMatricule())!=0)
		{	if(V.getNumMatricule().compare(NumMatricule)==0)
			{	
				N = V.getNumParking();
			}
			k=V.getNumMatricule();
		}
	}
}
myfile3.close();

myfile4.open(ParkingFileName.c_str());
myfile_temp.open(FileNameTemp.c_str(),ios::app);

if((!myfile4.is_open())&&(!myfile_temp.is_open()))
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Parking ou Fichier temp  "<<endl;
	return false;
}

else
{int k=0;
	while(!myfile4.eof())
	{	myfile4>>P;
		if(k!=P.getNumParking())
		{
			if((P.getNumParking()==N)&&(P.getNombreDePlaceOccupe()>0))
			{	int X=P.getNombreDePlaceOccupe()-1;
				P.setNombreDePlaceOccupe(X);
				myfile_temp<<P<<endl;}
			else
			{	myfile_temp<<P<<endl;
			}
			k=P.getNumParking();
		}
		else
		{
		}
	}
myfile4.close();
myfile_temp.close();
		remove(ParkingFileName.c_str());
		rename(FileNameTemp.c_str(),ParkingFileName.c_str());
}
return true;
}


//////////////////////////////////////////////////////////ReserverVehiculeTouristique//////////////////////////////////////////////////////////////

bool Agence::ReserverVehiculeTouristique(const Reservation& RE)
{
ofstream myfile2;			
myfile2.open(ReserverVehiculeFileName.c_str(),ios::app);
	
if(!myfile2.is_open())
{	cout<<"impossible d'ouvrir le Fichier : Fichier_Client ou Fichier Reservation "<<endl;
	return false;
}
else
{	myfile2<<RE<<endl;
}
myfile2.close();
return true;
}

///////////////////////////////////////////////////////////tester dispo V T/////////////////////////////////////////////////////////////////////////
bool Agence::TesterEtatDeDisponibiliteReserverTouristique(string NumMatricule )
{
ifstream myfile3;
VehiculeTouristique V;

myfile3.open(Vehicule_touristiqueFileName.c_str());
if(!myfile3.is_open())
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Vehicule ou Fichier temp  "<<endl;
	return false;
}
else
{	while(!myfile3.eof())
	{	myfile3>>V;
		if(V.getNumMatricule().compare(NumMatricule)==0)
		{	if (V.getEtatDeDisponibilite()==1)
			{	return false;
			}
		}
	}
myfile3.close();
}
return true;
}

/////////////////////////////////////////////////////////touristique////////////////////////////////////////////////////////////////////////////////
bool Agence::ChangerEtatDeDisponibiliteReserverTouristique(string NumMatricule)
{
ifstream myfile3;
ofstream myfiletemp;
VehiculeTouristique V;

myfile3.open(Vehicule_touristiqueFileName.c_str());
myfiletemp.open(FileNameTemp.c_str(),ios::app);
if((!myfile3.is_open())&&(!myfiletemp.is_open()))
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Vehicule ou Fichier temp  "<<endl;
	return false;
}

else
{string k="0";
	while(!myfile3.eof())
	{	myfile3>>V;
		if(k.compare(V.getNumMatricule())!=0)
		{	if(V.getNumMatricule().compare(NumMatricule)==0)
			{	V.setEtatDeDisponibilite(1);
				V.setNumParking(0);
				myfiletemp<<V<<endl;
			}
			else
			{	myfiletemp<<V<<endl;
			}
			k=V.getNumMatricule();
		}
		else
		{
		}
	}
myfile3.close();
myfiletemp.close();
		remove(Vehicule_touristiqueFileName.c_str());
		rename(FileNameTemp.c_str(),Vehicule_touristiqueFileName.c_str());
}
return true;
}
		
//////////////////////////////////////////////////////Reserver Vehicule Utilitaire////////////////////////////////////////////////////////////////////////////////////////

bool Agence::ReserverVehiculeUtilitaire (const Reservation& RE)
{
ofstream myfile;
myfile.open(ReserverVehiculeFileName.c_str(),ios::app);

if(!myfile.is_open())
{	cout<<"impossible d'ouvrir le Fichier : Fichier_Client ou Fichier Reservation "<<endl;
	return false;
}
else
{	myfile<<RE<<endl;
}
return true;
}

////////////////////////////////////////////////////////tester dispo V U///////////////////////////////////////////////////////////////////////////
bool Agence::TesterEtatDeDisponibiliteReserverUtilitaire( string NumMatricule)
{
ifstream myfile3;
VehiculeUtilitaire V;
myfile3.open(Vehicule_utilitaireFileName.c_str());

if(!myfile3.is_open())
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Vehicule ou Fichier temp  "<<endl;
	return false;
}
else
{	while(!myfile3.eof())
	{	myfile3>>V;
		if(V.getNumMatricule().compare(NumMatricule)==0)		
		{	if (V.getEtatDeDisponibilite()==1)
			{	return false;
			}
		}
	}
myfile3.close();
}
return true;
}
///////////////////////////////////////////////////////reserver dispo vehi utili///////////////////////////////////////////////////////////////////
bool Agence::ChangerEtatDeDisponibiliteReserverUtilitaire( string NumMatricule)
{
ifstream myfile3;
ofstream myfiletemp;

VehiculeUtilitaire V;

myfile3.open(Vehicule_utilitaireFileName.c_str());
myfiletemp.open(FileNameTemp.c_str(),ios::app);
if((!myfile3.is_open())&&(!myfiletemp.is_open()))
{	cout<<"impossible d'ouvrir un des deux Fichiers : Fichier_Vehicule ou Fichier temp  "<<endl;
	return false;
}
else
{string k="0";
	while(!myfile3.eof())
	{	myfile3>>V;
		if(k.compare(V.getNumMatricule())!=0)
		{	if(V.getNumMatricule().compare(NumMatricule)==0)
			{	V.setEtatDeDisponibilite(1);
				V.setNumParking(0);
				myfiletemp<<V<<endl;}
			else
			{	myfiletemp<<V<<endl;
			}
			k=V.getNumMatricule();
		}
		else
		{
		}
	}
	
myfile3.close();
myfiletemp.close();
		remove(Vehicule_utilitaireFileName.c_str());
		rename(FileNameTemp.c_str(),Vehicule_utilitaireFileName.c_str());
}
return true;
}

ofstream& operator<< (ofstream& out , const Agence& A)
{
out<<A.getNomAgence()<<"\t"
<<A.getNumAgence()<<"\t"
<<A.getAdresseAgence()<<"\t"
<<A.getTel()<<"\t"
<<A.getNomAgent()<<"\t"
<<A.getIdentifiantAgent()<<"\t"
<<A.getLogin()<<"\t"
<<A.getPassword();
return out;
}

ostream& operator<< (ostream& out , const Agence& A)
{
out<<"Nom de l'agence : "<<A.getNomAgence()<<"\t"
<<"N°agence : "<<A.getNumAgence()<<"\t"
<<"Adresse de l'agence : "<<A.getAdresseAgence()<<"\t"
<<"Tel : "<<A.getTel()<<"\t"
<<"Nom de l'agent : "<<A.getNomAgent()<<"\t"
<<"Identifiant agent : "<<A.getIdentifiantAgent()<<"\t"
<<"Login : "<<A.getLogin()<<"\t"
<<"Mot de passe : "<<A.getPassword();
return out;
}


ifstream& operator>> (ifstream& in,Agence& A)
			{
			in>>A.NomAgence;
			in>>A.NumAgence;
			in>>A.AdresseAgence;
			in>>A.Tel;
			in>>A.NomAgent;
			in>>A.IdentifiantAgent;
			in>>A.Login,
			in>>A.Password;
			return in;
			}
			
			
istream& operator>> (istream& in,Agence& A)
			{
			in>>A.NomAgence;
			in>>A.NumAgence;
			in>>A.AdresseAgence;
			in>>A.Tel;
			in>>A.NomAgent;
			in>>A.IdentifiantAgent;
			in>>A.Login,
			in>>A.Password;
			return in;
			}			
